package com.sinopec.pi.scalaguide.concurrent
import scala.concurrent.{Await, Future, Promise, duration}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Failure, Success}

object FutureUsage {
    private def longRunningAlgorithm() = {
        Thread.sleep(3000)
        42
    }

    private def futureExample(): Unit = {
        // 将任务封装成异步执行，使用内部全局的线程池
        val eventualInt = Future(longRunningAlgorithm())

        println(eventualInt)

        eventualInt.onComplete {
            case Success(value) => println(s"Got the callback，value = $value")
            case Failure(e) => e.printStackTrace()
        }

        // 等待异步执行完，否则进程退出，回调不会执行
        Await.ready(eventualInt, duration.Duration.Inf)
    }

    def promiseExample(): Unit = {
        // 创建一个Promise[Int]
        val promise = Promise[Int]()
        // 获取与Promise关联的Future
        val future: Future[Int] = promise.future
        // 在后台线程中完成Promise
        Future {
            // 假设这里有一些耗时的计算
            Thread.sleep(1000) // 模拟耗时操作
            val result = 42 // 假设这是计算结果

            // 完成Promise，onComplete 会被回调
            promise.success(result)
            // 失败场景，可以通过 failure 函数
            // promise.failure(new RuntimeException("异步操作失败！"))
        }(global) // 使用全局ExecutionContext来异步执行

        // 等待Future完成并打印结果
        future.onComplete {
            case Success(value) => println(s"异步操作的结果是: $value")
            case Failure(exception) => println(s"异步操作失败: ${exception.getMessage}")
        }

        // 等待异步执行完，否则进程退出，回调不会执行
        Await.ready(future, duration.Duration.Inf)
    }

    def main(args: Array[String]): Unit = {
        futureExample()

        promiseExample()
    }
}
